JVM

1. JVM学习路线

预科知识

JVM Java Virtual Machine - java 程序的运行环境（java 二进制字节码的运行环境）

JVM运行优点

• 一次编写，到处运行
• 自动内存管理，垃圾回收功能
• 数组下标越界检查
• 多态

对比 jvm jre jdk

学习路线

JVM学习路线

1. JVM内存结构
2. GC
3. 类文件
4. 字节码
5. JMM

常见 JVM

我们讲的以 HotSpot 为主

维基参考

JVM资料参考

2. JVM内存结构

1. 程序计数器
2. 虚拟机栈
3. 本地方法栈
4. 堆
5. 方法区

程序计数器

Program Counter Register 程序计数器（通过寄存器实现 –寄存器是CPU读取最快的空间）

• 作用，是记住下一条jvm指令的执行地址
• ==特点==
  • ==是线程私有的==
  • ==不会存在内存溢出==

作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

0: getstatic #20 // PrintStream out = System.out;
3: astore_1 // --
4: aload_1 // out.println(1);
5: iconst_1 // --
6: invokevirtual #26 // --
9: aload_1 // out.println(2);
10: iconst_2 // --
11: invokevirtual #26 // --
14: aload_1 // out.println(3);
15: iconst_3 // --
16: invokevirtual #26 // --
19: aload_1 // out.println(4);
20: iconst_4 // --
21: invokevirtual #26 // --
24: aload_1 // out.println(5);
25: iconst_5 // --
26: invokevirtual #26 // --
29: return

时间片概念：时间片即CPU分配给各个程序的时间，每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的

每个线程都有自己的程序计数器

虚拟机栈

虚拟机栈概念

Java Virtual Machine Stacks （Java 虚拟机栈）

• 每个线程运行时所需要的内存，称为虚拟机栈
• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

思考

1. 垃圾回收是否涉及栈内存？垃圾回收不管理栈内存 -> 垃圾回收只回收堆内存，而栈内存在每次栈帧执行完弹栈时都会释放
2. 栈内存分配越大越好吗？栈内存越大，只能使同一线程函数递归的次数越多，并不是越大越好 -> Linux 1024KB; macOS 1024KB; Windows The default value depends on virtual memory (栈内存越大 -> 线程数越少 因为物理内存是一定的 例如总物理 500M 一个线程 1M 理论上可以有 500个线程；如果每个栈内存 2M 理论上只能有 250个线程运行)
3. 方法内的局部变量是否线程安全？
   • 如果方法内局部变量**没有逃离方法的作用访问(参数传入，或 return 传出)**，它是线程安全的 int x = 0
   • 如果是局部变量引用了对象，**并逃离方法的作用范围(参数传入，或 return 传出)**，需要考虑线程安全 static int x = 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class Demo1_17 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append(4);
        sb.append(5);
        sb.append(6);
        new Thread(()->{
            m2(sb);
        }).start();
    }

    public static void m1() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;
    }
}

参考 Java 参数文档

https://docs.oracle.com/javase/8/

https://docs.oracle.com/en/java/javase/11/

https://docs.oracle.com/en/java/javase/11/tools/java.html

https://docs.oracle.com/en/java/javase/17/

栈内存溢出

栈帧过多导致栈内存溢出

• 栈帧过多导致栈内存溢出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class Demo1_1 {
    public static void main(String[] args) throws InterruptedException {
        method1();
    }

    private static void method1() {
        method2(1, 2);
    }

    private static int method2(int a, int b) {
        int c =  a + b;
        return c;
    }
}

public class Demo1_2 {
    private static int count;

    public static void main(String[] args) {
        try {
            method1();
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(count);
        }
    }

    private static void method1() {
        count++;
        method1();
    }
}

StackOverFlowError

栈帧过大导致栈内存溢出

• 栈帧过大导致栈内存溢出

设置栈size

1

-Xss256k

第三方库导致 StackOverFlowError

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package cn.itcast.jvm.t1.stack;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.List;

/**
 * json 数据转换
 */
public class Demo1_19 {

    public static void main(String[] args) throws JsonProcessingException {
        Dept d = new Dept();
        d.setName("Market");

        Emp e1 = new Emp();
        e1.setName("zhang");
        e1.setDept(d);

        Emp e2 = new Emp();
        e2.setName("li");
        e2.setDept(d);

        d.setEmps(Arrays.asList(e1, e2));

        // { name: 'Market', emps: [{ name:'zhang', dept:{ name:'', emps: [ {}]} },] }
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(d));
    }
}

class Emp {
    private String name;
    @JsonIgnore
    private Dept dept;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}
class Dept {
    private String name;
    private List<Emp> emps;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Emp> getEmps() {
        return emps;
    }

    public void setEmps(List<Emp> emps) {
        this.emps = emps;
    }
}

线程运行诊断

问题1

cpu 占用过多

定位

• 用top定位哪个进程对cpu的占用过高
• ps H -eo pid,tid,%cpu | grep 进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
• jstack 进程id
  • 可以根据线程id (nid) 找到有问题的线程，进一步定位到问题代码的源码行号

Java占用内存过高

top查看

1
2
3
4
5
6
7

# 查看当前所有线程相对应指标
ps H -eo pid,tid,%cpu

ps H -eo pid,tid,%cpu | grep 32655

# jdk提供
jstack 32655

问题2

程序运行很长时间没有结果

有可能因为线程死锁

1
2

nohup java cn.itcast.jvm.t1.Demo1_3&
nohup: ignoring input and appending output to `nohup.out`

排查线程死锁

1

jstack 32655

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * 演示线程死锁
 */
class A{};
class B{};
public class Demo1_3 {
    static A a = new A();
    static B b = new B();


    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (a) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
        Thread.sleep(1000);
        new Thread(()->{
            synchronized (b) {
                synchronized (a) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
    }
}

本地方法栈

本地方法接口指 -> 不是由Java代码编写，由于Java代码有一定的限制，不能直接操作OS底层，所以就需要使用 c/c++ 编写的本地方法来与操作OS底层的API对接 -> Java代码可以间接通过本地方法来操作OS，而本地方法运行时使用的内存就是本地方法栈

native修饰的本地方法

堆

堆概念

Heap 堆

• 通过 new 关键字，创建对象都会使用堆内存

特点

• 它是线程共享的，堆中对象都需要考虑线程安全的问题
• 有垃圾回收机制

堆内存溢出

堆内存诊断

1. jsp工具
   • 查看当前系统中有哪些 java 进程
2. jmap
   • 查看堆内存占用情况 jmap - heap 进程id –查看某一时刻，类似于快照
3. jconsole
   • 图形界面的，多功能的监测工具，可以连续监测
4. jvirsualvm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * 演示堆内存溢出 java.lang.OutOfMemoryError: Java heap space
 * -Xmx8m
 */
public class Demo1_5 {

    public static void main(String[] args) {
        int i = 0;
        try {
            List<String> list = new ArrayList<>();
            String a = "hello";
            while (true) {
                list.add(a); // hello, hellohello, hellohellohellohello ...
                a = a + a;  // hellohellohellohello
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(i);
        }
    }
}

OutOfMemoryError

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * 演示堆内存
 */
public class Demo1_4 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("1...");
        Thread.sleep(30000);
        byte[] array = new byte[1024 * 1024 * 10]; // 10 Mb
        System.out.println("2...");
        Thread.sleep(20000);
        array = null;
        System.gc();
        System.out.println("3...");
        Thread.sleep(1000000L);
    }
}

1
2

jmap -heap 18756
jmap -heap <进程id>

jconsole

垃圾回收后，内存占用仍然很高

1
2

# jdk提供
jvisualvm

方法区

方法区概念

方法区概念

方法区是所有Java虚拟机线程共享的区域（此特点类似堆），方法区中存储与类结构相关的信息（类 field, method data, methods, constructions 包含 special methods），同样包含 run-time constant pool，运行时常量池

==定义概念上，方法区是 heap 的一部分，但是具体的厂商在完成不同 JVM 的实现时，不一定会遵循定义概念==

规范并不强制方法区的实现位置 -> jdk8 以前的 hotspot 方法区的实现叫做永久带（就是使用堆内存的一部分）-> jdk1.8 之后的方法区实现换了一种方式叫做元空间（用的就不是堆内存，而是本地内存 -> 直接操作系统内存）-> 不同实现就导致方法区的位置不同

同样方法区也会导致 OutOfMemoryError

The Java Virtual Machine has a method area that is shared among all Java Virtual Machine threads. The method area is analogous to the storage area for compiled code of a conventional language or analogous to the “text” segment in an operating system process. It stores per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors, including the special methods (§2.9) used in class and instance initialization and interface initialization.

The method area is created on virtual machine start-up. Although the method area is logically part of the heap, simple implementations may choose not to either garbage collect or compact it. This specification does not mandate the location of the method area or the policies used to manage compiled code. The method area may be of a fixed size or may be expanded as required by the computation and may be contracted if a larger method area becomes unnecessary. The memory for the method area does not need to be contiguous.

A Java Virtual Machine implementation may provide the programmer or the user control over the initial size of the method area, as well as, in the case of a varying-size method area, control over the maximum and minimum method area size.

The following exceptional condition is associated with the method area:

• If memory in the method area cannot be made available to satisfy an allocation request, the Java Virtual Machine throws an OutOfMemoryError.

官方定义

组成图

• jdk1.6 常量池 -> 运行时常量池 -> 包含 StringTable
• ==jdk1.8 之后，方法区就被移到本地内存中 -> 称为元空间 -> 而 StringTable 则被移到 Heap 堆空间中==

方法区内存溢出

• 1.8 以前会导致永久代内存溢出

1
2

* 演示永久代内存溢出 java.lang.OutOfMemoryError: PermGen space
* -XX:MaxPermSize=8m

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * 演示永久代内存溢出  java.lang.OutOfMemoryError: PermGen space
 * -XX:MaxPermSize=8m
 */
public class Demo1_8 extends ClassLoader {
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 test = new Demo1_8();
            for (int i = 0; i < 20000; i++, j++) {
                ClassWriter cw = new ClassWriter(0);
                cw.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                byte[] code = cw.toByteArray();
                test.defineClass("Class" + i, code, 0, code.length);
            }
        } finally {
            System.out.println(j);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
 * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m
 */
public class Demo1_8 extends ClassLoader { // 可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 test = new Demo1_8();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter 作用是生成类的二进制字节码
                ClassWriter cw = new ClassWriter(0);
                // 版本号， public， 类名, 包名, 父类， 接口
                cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回 byte[]
                byte[] code = cw.toByteArray();
                // 执行了类的加载
                test.defineClass("Class" + i, code, 0, code.length); // Class 对象
            }
        } finally {
            System.out.println(j);
        }
    }
}

• 1.8 之后会导致元空间内存溢出

1
2

* 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
* -XX:MaxMetaspaceSize=8m

案例

• spring
• mybatis

运行时常量池

常量池

常量池，就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等信息

运行时常量池

运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

1
2
3
4
5
6

// 二进制字节码（类基本信息，常量池，类方法定义，包含了虚拟机指令）
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

借助jdk提供的反编译工具 javap -v HelloWorld.class -> -v 显示反编译后的详细信息

1

E:\Todo\note\Software\Java_Note\Code\JavaCode\out\production\JavaCode\Test02> javap -v .\HelloWorld.class

==得到反编译后的详细信息==

主要部分包括类 -> 基本信息，常量池，类方法定义，包含了虚拟机指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

Classfile /E:/Todo/note/Software/Java_Note/Code/JavaCode/out/production/JavaCode/Test02/HelloWorld.class
  Last modified 2023-1-29; size 547 bytes      
  MD5 checksum c9ba0a6bb02e055dc5d4a83327a04608
  Compiled from "HelloWorld.java"              
public class Test02.HelloWorld                 
  minor version: 0                             
  major version: 52                            
  flags: ACC_PUBLIC, ACC_SUPER                 
Constant pool:                                 
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // Test02/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               LTest02/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               Test02/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public Test02.HelloWorld();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LTest02/HelloWorld;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

运行时常量池

运行时常量池，常量池是 *.class 文件中的，当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Constant pool:                                 
   #1 = Methodref          #6.#20         // java/lang/Object."<init>":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // Test02/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               LTest02/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "<init>":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               Test02/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V

• 当该类被加载，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址 -> 内存地址 0xXXXX

StringTable

StringTable –字符串常量池，又称串池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构，不能扩容
public class Demo1_22 {
    // 常量池中的信息，都会被加载到运行时常量池中， 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象
    // ldc #2 会把 a 符号变为 "a" 字符串对象
    // ldc #3 会把 b 符号变为 "b" 字符串对象
    // ldc #4 会把 ab 符号变为 "ab" 字符串对象

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2; // new StringBuilder()[init初始化].append("a").append("b").toString()  new String("ab")
        String s5 = "a" + "b";  // javac 在编译期间的优化，结果已经在编译期确定为ab
	s3 == s4;	// false -> s3 是串池中的，而s4是堆内存中new 的，所以是两个对象
        s3 == s5;	// true -> 字符串常量池就是在编译期间，将所用到的，能直接识别的 String（即 "" 的String） 放入串池中。同时进行编译优化 "a" + "b" 的字符串，同样会在串池中保存 -> "ab" -> 如果串池中已经存在 "ab" 则会直接找到 "ab"，而不需要再次放入
            
        System.out.println(s3 == s5);
    }
}

==字符串常量池就是在编译期间，将所用到的，能直接识别的 String（即 “” 的String） 放入串池中。同时进行编译优化 “a” + “b” 的字符串，同样会在串池中保存 -> “ab” -> 如果串池中已经存在 “ab” 则会直接找到 “ab”，而不需要再次放入==

字符串延迟加载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * 演示字符串字面量也是【延迟】成为对象的
 */
public class TestString {
    public static void main(String[] args) {
        int x = args.length;
        System.out.println(); // 字符串个数 2275 断点

        System.out.print("1");
        System.out.print("2");
        System.out.print("3");
        System.out.print("4");
        System.out.print("5");
        System.out.print("6");
        System.out.print("7");
        System.out.print("8");
        System.out.print("9");
        System.out.print("0");
        System.out.print("1"); // 字符串个数 2285 断点
        System.out.print("2");
        System.out.print("3");
        System.out.print("4");
        System.out.print("5");
        System.out.print("6");
        System.out.print("7");
        System.out.print("8");
        System.out.print("9");
        System.out.print("0");
        System.out.print(x); // 字符串个数 断点
    }
}

面试案例题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

String s1 = "a";
String s2 = "b";
String s3 = "a" + "b";
String s4 = s1 + s2;
String s5 = "ab";
String s6 = s4.intern();
// 问
System.out.println(s3 == s4);	// false
System.out.println(s3 == s5);	// true
System.out.println(s3 == s6);	// true
String x2 = new String("c") + new String("d");	// heap
String x1 = "cd";	// pool
x2.intern();
// 问，如果调换了【最后两行代码】的位置呢（true），如果换位置后是 jdk1.6呢（false）
System.out.println(x1 == x2);	// false

Intern()方法

==将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回==

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Demo1_23 {
    // jdk8
    
    //  ["ab", "a", "b"]
    public static void main(String[] args) {
        String x = "ab";
        String s = new String("a") + new String("b");

        // 堆  new String("a")   new String("b") new String("ab")
        String s2 = s.intern(); // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
	// 如果没有放入，则 s2 为 串池中的 字符串，而 s 为堆中的字符串 s2 != s
        
        System.out.println( s2 == x);
        System.out.println( s == x );
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Demo1_23 {
    // jdk1.6
    
    // ["a", "b", "ab"]
    public static void main(String[] args) {
        String s = new String("a") + new String("b");

        // 堆  new String("a")   new String("b")  new String("ab")
        String s2 = s.intern(); // 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
        // s 拷贝一份，放入串池

        String x = "ab";	// 串池中存在 ab 就直接使用
        System.out.println( s2 == x);	// true
        System.out.println( s == x );	// false -> 1.8 true
    }
}

StringTable 特性

• 常量池中的字符串仅是符号，第一次用到时才变为对象
• 利用串池的机制，来避免重复创建字符串对象
• 字符串变量拼接的原理是 StringBuilder （1.8）
• 字符串常量拼接的原理是编译期优化
• 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
  • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
  • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池，会把串池中的对象返回 -> 即调用 intern 的对象 与 最终放入串池中的对象是两个不同的对象

StringTable 位置

==jdk1.8 之后 StringTable 转换位置的原因 -> 在jdk1.6 时，StringTable 是 永久带实现 -> 必须等到老年代内存空间不足，才会执行 full gc 来回收，而 StringTable 本身是需要很频繁的使用和回收 -> 而堆 heap 中只需要 Minor GC 就可以回收空间 -> 从而减少StringTable内存的优化==

验证 StringTable 位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * 演示 StringTable 位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit
 * 在jdk6下设置 -XX:MaxPermSize=10m
 */
public class Demo1_6 {

    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                list.add(String.valueOf(j).intern());
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

/*
jdk1.6
java.lang.OutOfMemoryError: PermGen space

jdk1.8
java.lang.OutOfMemoryError: GC overhead limit exceeded
*/

官方文档

-XX:+UseGCOverheadLimit

Enables the use of a policy that limits the proportion of time spent by the JVM on GC before an OutOfMemoryError exception is thrown. This option is enabled, by default and the parallel GC will throw an OutOfMemoryError if more than 98% of the total time is spent on garbage collection and less than 2% of the heap is recovered. When the heap is small, this feature can be used to prevent applications from running for long periods of time with little or no progress. To disable this option, specify -XX:-UseGCOverheadLimit.

StringTable 垃圾回收机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Demo1_7 {
    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        try {
            for (int j = 0; j < 100000; j++) { // j=100, j=10000
                String.valueOf(j).intern();
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

StringTable 性能调优

StringTable 底层是一个 hash 表

• 调整 -XX:StringTableSize=桶个数
• 考虑将字符串对象是否入池 -> 字符串是否需要重复使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * 演示串池大小对性能的影响
 * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1009 --> 48w的单词 分散在 1009 个桶里 -> 平均每需要 12097ms 
 * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000 --> 48w的单词 分散在 20w 个桶里 -> 平均每个桶里 2 个单词，所以只需要 401ms 速度相当快
 */
public class Demo1_24 {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
            String line = null;
            long start = System.nanoTime();
            while (true) {
                line = reader.readLine();
                if (line == null) {
                    break;
                }
                line.intern();
            }
            System.out.println("cost:" + (System.nanoTime() - start) / 1000000);
        }
    }
}

空间换时间

字符串是否需要重复使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * 演示 intern 减少内存占用
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 * -Xsx500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000
 */
public class Demo1_25 {
    public static void main(String[] args) throws IOException {
        List<String> address = new ArrayList<>();
        System.in.read();
        for (int i = 0; i < 10; i++) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
                String line = null;
                long start = System.nanoTime();
                while (true) {
                    line = reader.readLine();
                    if(line == null) {
                        break;
                    }
                    address.add(line.intern());
                }
                System.out.println("cost:" +(System.nanoTime()-start)/1000000);
            }
        }
        System.in.read();
    }
}

加上入池动作

直接内存

直接内存概念

Direct Memory --直接内存不属于 JVM 内存管理，而是属于OS系统内存，可被JVM调用

• 常见于 NIO 操作时，用于数据缓冲区
• 分配回收成本较高，但读写性能高
• ==不受 JVM 内存回收管理==

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

/**
 * 演示 ByteBuffer 作用
 */
public class Demo1_9 {
    static final String FROM = "E:\\编程资料\\第三方教学视频\\youtube\\Getting Started with Spring Boot-sbPSjI4tt10.mp4";
    static final String TO = "E:\\a.mp4";
    static final int _1Mb = 1024 * 1024;

    public static void main(String[] args) {
        io(); // io 用时：1535.586957 1766.963399 1359.240226
        directBuffer(); // directBuffer 用时：479.295165 702.291454 562.56592
    }

    private static void directBuffer() {
        long start = System.nanoTime();
        try (FileChannel from = new FileInputStream(FROM).getChannel();
             FileChannel to = new FileOutputStream(TO).getChannel();
        ) {
            ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
            while (true) {
                int len = from.read(bb);
                if (len == -1) {
                    break;
                }
                bb.flip();
                to.write(bb);
                bb.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
    }

    private static void io() {
        long start = System.nanoTime();
        try (FileInputStream from = new FileInputStream(FROM);
             FileOutputStream to = new FileOutputStream(TO);
        ) {
            byte[] buf = new byte[_1Mb];
            while (true) {
                int len = from.read(buf);
                if (len == -1) {
                    break;
                }
                to.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("io 用时：" + (end - start) / 1000_000.0);
    }
}

直接内存原理

直接内存原理

常规IO

• Java代码不能操作系统缓冲区
• 可以对应操作 Java缓冲区 –缓冲区copy -> 性能开销

直接内存NIO

内存溢出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * 演示直接内存溢出
 */
public class Demo1_10 {
    static int _100Mb = 1024 * 1024 * 100;

    public static void main(String[] args) {
        List<ByteBuffer> list = new ArrayList<>();
        int i = 0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                list.add(byteBuffer);
                i++;
            }
        } finally {
            System.out.println(i);
        }
        // 方法区是jvm规范， jdk6 中对方法区的实现称为永久代
        //                  jdk8 对方法区的实现称为元空间
    }
}

java.lang.OutOfMemoryError: Direct buffer memory

分配和回收原理

• 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
• ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程 [守护线程] 通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 禁用显式回收对直接内存的影响
 */
public class Demo1_26 {
    static int _1Gb = 1024 * 1024 * 1024;

    /*
     * -XX:+DisableExplicitGC 显式的
     */
    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
        System.out.println("分配完毕...");
        System.in.read();
        System.out.println("开始释放...");
        byteBuffer = null;
        System.gc(); // 显式的垃圾回收，Full GC
        System.in.read();
    }
}

• 开辟1G直接内存，==执行 GC 会并不会释放直接内存==，而是需要通过调用 Unsafe 来释放直接内存
• 而 DirectByteBuffer类会主动调用 cleanner[虚引用对象]* 自身会控制 Unsafe 来释放 直接内存*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * 直接内存分配的底层原理：Unsafe
 */
public class Demo1_27 {
    static int _1Gb = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存
        unsafe.freeMemory(base);
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

JVM调优时会经常使用 -> -XX: +DisableExplicitGC 显示的 -> 使代码中显示的调用 System.gc() 失效

因为 System.gc() 触发的使 full GC -> 从而导致性能的严重降低

但是使用 -XX: +DisableExplicitGC 显示的 禁用了代码层面的 gc，就有可能影响直接内存的回收

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 禁用显式回收对直接内存的影响
 */
public class Demo1_26 {
    static int _1Gb = 1024 * 1024 * 1024;

    /*
     * -XX:+DisableExplicitGC 显式的
     */
    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
        System.out.println("分配完毕...");
        System.in.read();
        System.out.println("开始释放...");
        byteBuffer = null;
        System.gc(); // 显式的垃圾回收，Full GC
        System.in.read();
    }
}

• 由于 ByteBuffer 对象任然存活，没有被 GC，那么它所对应的直接内存就也没有被回收
• 所以使用 -XX: +DisableExplicitGC 显示的 禁用了代码层面的 gc，对其他内存没有影响，但是会影响直接内存的回收
• 可以用 Unsafe 对象直接手动管理 直接内存

3. 垃圾回收 GC

1. 判断对象可以回收的机制
2. 垃圾回收算法
3. 分代垃圾回收
4. 垃圾回收器
5. 垃圾回收调优

对象垃圾回收条件

两种判断方式

1. 引用计数法
2. 可达性分析算法

引用计数法

无法处理循环引用问题，AB对象循环引用，导致无法被引用计数法回收内存 -> 从而导致内存泄漏

由于两个对象的引用数不能清零，所以导致 GC 始终无法回收这两个对象

==早期的 python VM 使用了这个 引用计数法 来实现 GC，而 JVM 并没有使用这个方式 GC，而是使用 可达性分析算法实现 GC==

可达性分析算法

可达性分析算法，首先确定肯定不能回收的对象为根对象，在GC前，先扫描堆中的对象，看是否能够沿着 GC Root对象 为起点的引用链找到该对象，找不到，表示可以回收

• Java 虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
• 扫描堆中的对象，看是否能够沿着 GC Root对象 为起点的引用链找到该对象，找不到，表示可以回收
• 哪些对象可以作为 GC Root ?

Memory Analyzer（MAT）

The Eclipse Memory Analyzer is a fast and feature-rich Java heap analyzer that helps you find memory leaks and reduce memory consumption.

Use the Memory Analyzer to analyze productive heap dumps with hundreds of millions of objects, quickly calculate the retained sizes of objects, see who is preventing the Garbage Collector from collecting objects, run a report to automatically extract leak suspects.

–Java对象分析工具

演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * 演示GC Roots
 */
public class Demo2_2 {

    public static void main(String[] args) throws InterruptedException, IOException {
        List<Object> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        System.out.println(1);
        System.in.read();

        list1 = null;
        System.out.println(2);
        System.in.read();
        System.out.println("end...");
    }
}

1
2
3

jps
# b->二进制 live->存活对象(live会在快照前主动进行 GC) file -> 将快照存储在1.bin 文件中
jamp -dump:format=b,live,file=1.bin 21384

通过 MAT 查看 GC_ROOTS

Total: 4 entries

• System Class
• Native Stack
• Thread
• Busy Monitor

五种引用

1. 强引用
   • 只有所有 GC Roots 对象都不通过【强引用】引用该对象，该对象才能被垃圾回收
2. 软引用（SoftReference）
   • 仅有软引用引用该对象时，在垃圾回收后，内存仍不足时会再次出发垃圾回收，回收软引用对象
   • 可以配合引用队列来释放软引用自身
3. 弱引用（WeakReference）
   • 仅有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用对象
   • 可以配合引用队列来释放弱引用自身
4. 虚引用（PhantomReference） –关联引用队列
   • 必须配合引用队列使用，主要配合 ByteBuffer 使用，被引用对象回收时，会将虚引用入队（主要其引用对象被回收，而直接内存并没有被回收），由 Reference Handler 线程调用虚引用相关方法（调用Unsafe.freeMemory）释放直接内存
5. 终结器引用（FinalReference） –关联引用队列
   • 无需手动编码，但其内部配合引用队列使用，在垃圾回收时，终结器引用入队（被引用对象暂时没有被回收），再由 Finalizer 线程（一个优先级很低的线程）通过终结器引用找到被引用对象并调用它的 finalize 方法（ Object类中有一个 finalize()方法，当重写了 finalize()方法 –希望在 当前对象被GC时调用 并没有强引用引用其时，就可以被GC回收，回收时，进入终结器引用队列，通过 Finalizer线程扫描引用队列并执行其 finalize()方法后才会被回收 ），第二次 GC 时才能回收被引用对象

不推荐使用 finalize() 释放内存

软引用案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * 演示软引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_3 {

    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        /*List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new byte[_4MB]);
        }
        System.in.read();*/
        soft();
    }

    public static void soft() {
        // list --> SoftReference --> byte[]

        List<SoftReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB]);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }
        System.out.println("循环结束：" + list.size());
        for (SoftReference<byte[]> ref : list) {
            System.out.println(ref.get());
        }
    }
}

软引用配合引用队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * 演示软引用, 配合引用队列
 */
public class Demo2_4 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        List<SoftReference<byte[]>> list = new ArrayList<>();

        // 引用队列
        ReferenceQueue<byte[]> queue = new ReferenceQueue<>();

        for (int i = 0; i < 5; i++) {
            // 关联了引用队列， 当软引用所关联的 byte[]被回收时，软引用自己会加入到 queue 中去
            SoftReference<byte[]> ref = new SoftReference<>(new byte[_4MB], queue);
            System.out.println(ref.get());
            list.add(ref);
            System.out.println(list.size());
        }

        // 从队列中获取无用的 软引用对象，并移除
        Reference<? extends byte[]> poll = queue.poll();
        while( poll != null) {
            list.remove(poll);
            poll = queue.poll();
        }

        System.out.println("===========================");
        for (SoftReference<byte[]> reference : list) {
            System.out.println(reference.get());
        }
    }
}

弱引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * 演示弱引用
 * -Xmx20m -XX:+PrintGCDetails -verbose:gc
 */
public class Demo2_5 {
    private static final int _4MB = 4 * 1024 * 1024;

    public static void main(String[] args) {
        //  list --> WeakReference --> byte[]
        List<WeakReference<byte[]>> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            WeakReference<byte[]> ref = new WeakReference<>(new byte[_4MB]);
            list.add(ref);
            for (WeakReference<byte[]> w : list) {
                System.out.print(w.get()+" ");
            }
            System.out.println();
        }
        System.out.println("循环结束：" + list.size());
    }
}

软引用与弱引用都是避免强引用导致 OOM 问题

• 软引用 -> list –> SoftReference –> byte[]
• 弱引用 -> list –> WeakReference –> byte[]

垃圾回收算法

常见的三种回收算法

1. 标记清除法
2. 标记整理法
3. 复制回收法

标记清除法

定义： Mark Sweep

标记清除法主要分为两个阶段

沿着 GCROOT 寻找，==一阶段 -> 标记哪些没有引用的对象，将没有引用的对象标记为垃圾==。==二阶段 -> 再对标记的垃圾对象进行回收，回收也并不是将内存直接释放，而是将所回收对象占用内存的起始地址与结束地址存储在空闲内存列表中==.当再次分配此段内存时，进行覆盖

特点：

• 速度较快
• 会造成内存碎片

标记整理法

定义：Mark Compact

特点：

• 速度较慢
• 没有内存碎片

复制回收法

定义：Copy

特点：

• 不会有内存碎片
• 需要占用双倍内存空间

分代垃圾回收

分代垃圾回收概念

新生代处理生命周期短的对象，老年代处理生命周期长的对象 –针对不同区域采用不同的垃圾回收方法（垃圾分类）

==工作原理：== –空间不足时才会触发 GC

• 对象创建后首先分配在伊甸园区域 -> 伊甸园区域内存不足时，就会触发 minor gc -> copy（通过幸存区 From To 实现） 存活的对象到 幸存区 ，并使其 年龄+1
• 新生代空间不足时，触发 minor gc，伊甸园和 from 存活的对象使用 copy 复制到 to 中，存活的对象年龄加 1并且交换 from to
• minor gc 会引发 stop the world（minor gc触发 STW 的时间很小），暂停其它用户的线程，等垃圾回收结束，用户线程才恢复运行
• 当对象寿命超过阈值时，**会晋升至老年代**，最大寿命是15（4bit）
• 当老年代空间不足，会先尝试触发 minor gc，如果之后空间仍不足，那么触发 full gc，STW的时间更长

进入老年代的方式

1. 占用内存较大的对象，直接进入老年代

   • 程序一般认为大对象有可能是需要存活比较长时间的对象，而且大对象在幸存区返回来回复制，影响young GC的效率，
   • 通过-XX:PretenureSizeThreshold进行设置

2. 年龄达到阈值

   • 通过-XX:MaxTenuringThreshold进行设置，默认为15

3. 动态年龄判断

   • 当一个对象从Eden区到了Survivor区，当 Survivor 空间中相同年龄所有对象的大小总和大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，而不需要达到默认的分代年龄

4. 幸存区的内存不足

   1 2 3

   -XX:NewSize=10485760 -XX:MaxNewSize=10485760 -XX:InitialHeapSize=20971520 -XX:MaxHeapSize=20971520 -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=5242880 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc.log # 新生代 10M 、伊甸区 8M、幸存区1 1M、幸存区2 1M、堆 20M、老年代 10M、年龄阈值是15、大对象是 10M；使用ParNewGC+CMS；打印相关gc日志到gc.log文件

   • 在幸存区内存不足时，会将部分对象放置到幸存区，部分对象放入老年代

相关 JVM 参数

GC案例

• 触发一次 MinorGC

• 将 eden space 占用提升到 98%

• 触发两次 MinorGC

• Big Object直接进入老年代

• 触发 OOM

• 虽然内存是线程共享，当前线程触发 OOM ，并不会影响已经在运行的线程(or 主线程)，除非其他线程再次需要开辟空间（or 引发OOM）

垃圾回收器

串行

特点

• 单线程
• 堆内存较小，适合个人电脑

参数

• -XX:+UseSerialGC = Serial + SerialOld
  • Serial 工作在新生代
  • SerialOld 工作在老年代

吞吐量优先

特点

• 多线程 –并行
• 堆内存较大，多核 cpu
• 让单位时间内，STW 的时间最短 0.2 0.2 = 0.4，垃圾回收时间占比最低，这样就称吞吐量高

参数

• -XX:+UseParallelGC ~ -XX:+UseParallelOldGC –jdk1.8默认开启
• -XX:+UseAdaptiveSizePolicy –自适应，调整各区域大小
• -XX:GCTimeRatio=ratio –调整GC与总时间占比
• -XX:MaxGCPauseMillis=ms –默认200ms 最大 GC STW 暂停时间
• -XX:ParallelGCThreads=n –控制CPU线程数

CPU占用趋势

响应时间优先

特点

• 多线程 –并行
• 堆内存较大，多核 cpu
• 尽可能让单次 STW 的时间最短 0.1 0.1 0.1 0.1 0.1 = 0.5

==CMSGC==

参数

• -XX:+UseConcMarkSweepGC ~ -XX:+UseParNewGC ~ SerialOld –用户线程与GC线程同时执行，同时争抢CPU时间片，开启回收器
• -XX:ParallelGCThreads=n ~ -XX:ConcGCThreads=threads –4 -> 1 n -> n/4
• -XX:CMSInitiatingOccupancyFraction=percent –执行CMS内存占比 -> 预留空间给浮动垃圾
• -XX:+CMSScavengeBeforeRemark –重新标记前，是否执行回收

CMS基于标记清除算法，有可能会造成大量 碎片内存 -> 从而引发并发失败，此时CMSGC就不能正常工作，导致退化成 SerialOldGC（串行整理 -> STW 时间特别长）

CPU占用趋势

G1

G1概念及原理

G1概念

Garbage First –Garbage One(一款很有年代的**垃圾回收器**，直到17年左右技术才相对成熟)

• 2004 论文发布
• 2009 JDK 6u14 体验
• 2012 JDK 7u4 官方支持
• 2017 JDK 9 纳为默认GC回收器 -> 从而取代CMS回收器

适用场景

• 同时注重吞吐量（Throughput）和低延迟（Low latency），默认的暂停目标是 200 ms
• 超大堆内存，会将堆划分为多个大小相等的 Region 每一个区都可以独立作为 Eden / Survive / Old (化整为零思想)
• 整体上 单个Region 是 标记+整理 算法，两个区域之间是 复制 算法

相关参数

• -XX:+UseG1GC –显示开启使用 G1 -> jdk1.9 后默认开启
• -XX:G1HeapRegionSize=size –设置 Region 大小 -> 最好/必须 设置成 2^n
• -XX:MaxGCPauseMillis=time

G1 垃圾回收阶段

阶段一

• Young Collection –新生代收集
  • 会导致 STW –相对较短

复制回收 copy -> survive

survive age -> threshold -> Old / surive

阶段二

• Young Collection + CM

  • 在 Young GC 时会进行 GC Root 的初始标记

  • 老年代占用堆空间比例达到阈值时，进行并发标记（不会 STW），由下面的 JVM 参数决定

    -XX:InitiatingHeapOccupancyPercent=percent –（默认45%）

mark

阶段三

• Mixed Collection –会对 E、S、O 进行全面垃圾回收

  • 最终标记（Remark）会 STW

  • 拷贝存活（Evacuation）会 STW

    -XX:MaxGCPauseMillis=ms –控制 MaxGC 的 STW 时间。G1 会挑出回收价值高的 Old 来进行回收，从而来达到 MaxGCPauseMillis 的限制

Full GC 辨析

• SerialGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• ParallelGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• CMS
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足 -分两种情况
• G1
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足 -分两种情况 -> threshold >= 45% -> 触发标记-清除-并发清理（不是 FullGC） -> 在 remark 期间判断当 垃圾产生速度 > GC 速度时 -> 触发 FullGC

Young Collection 跨代引用问题

为防止 search old 的时候开销太大，所以老年代存储使用一种卡表技术，老年代 region 细分化为 cards -> 每个card 大概 512k

• 新生代回收的跨代引用（老年代引用新生代）问题

==如果老年代有 card 引用了新生代的对象，就将此 card 标记为 脏卡== –从而减少 search old 开销

同时新生代也会使用 Remembered Set 来记录有哪些 old card 引用了这些新生代对象，达到减少 search 开销的目的

• 卡表与 Remembered Set
• 在引用变更（脏卡）时通过 post-write barrier（写屏障） + dirty card queue （脏卡队列）
• concurrent refinement threads 更新 Remembered Set

Remark 重标记

对 E、S、O 进行全面垃圾回收时，会有两个阶段情况，先进行 remark -> 判断是否需要 FullGC

原理

• pre-write barrier + satb_mark_queue

• 黑色 -> 已完成 remark 处理
• 灰色 -> 正在进行 remark / 未完成（待完成） remark
• 白色 -> 未进行 remark

问题：由于并发执行，如果在 remark 期间，有用户改变了对象之间的引用关系，就会导致，需要回收的对象没有被回收，不能回收的对象，被意外回收

–通过 pre-write barrier（写屏障） + satb_mark_queue（mark队列）来解决问题

在发生引用改变时，配合 写屏障 将引用改变的对象放入 markqueue，最后统一再进行一次 remark 处理 markqueque 中的对象

不同 jdk G1 优化

主要围绕 jdk 8 9

• JDK 8u20 字符串去重
  • 优点：节省大量内存
  • 缺点：略微多占用了 cpu 时间，新生代回收时间略微增加

-XX:+UseStringDeduplication

1
2

String s1 = new String("hello"); // char[]{'h','e','l','l','o'}
String s2 = new String("hello"); // char[]{'h','e','l','l','o'}

• 将所有新分配的字符串放入一个队列

• 当新生代回收时，G1并发检查是否有字符串重复

• 如果它们值一样，让它们引用同一个 char[]

• 注意，与 String.intern() 不一样

  • String.intern() 关注的是字符串对象
  • 而字符串去重关注的是 char[]
  • 在 JVM 内部，使用了不同的字符串表 –与 串池 对比使用了不同的字符串表

• JDK 8u40 并发标记类卸载

  所有对象都经过并发标记后，就能知道哪些类（包括实例）不再被使用，当一个类加载器的所有类都不再使用，则卸载它所加载的所有类

  -XX:+ClassUnloadingWithConcurrentMark 默认启用

• JDK 8u60 回收巨型对象

  • 一个对象大于 region 的一半时，称之为巨型对象 –G1会有巨型对象区
  • G1 不会对巨型对象进行拷贝
  • 回收时被优先考虑
  • G1 会跟踪老年代所有 incoming 引用，这样老年代 incoming 引用为0 的巨型对象就可以在新生代垃圾回收时处理掉(尽早回收)

• JDK 9 并发标记起始时间的调整

  • 并发标记（通过提前开始并发标记来优化 FullGC）必须在堆空间占满前完成，否则退化为 FullGC （虽然 FullGC 被优化为多线程，还是需要尽量减少）
  • JDK 9 之前需要使用 -XX:InitiatingHeapOccupancyPercent
  • JDK 9 可以动态调整
    • -XX:InitiatingHeapOccupancyPercent 用来设置初始值 例如 45%
    • 进行数据采样并动态调整
    • 总会添加一个安全的空档空间

• JDK 9 更高效的回收

  • 250+增强
  • 180+bug修复
  • https://docs.oracle.com/en/java/javase/19/gctuning/

垃圾回收调优

预备知识

• GC 相关的 VM 参数，会基本的空间调整
• 相关工具
• 切记调优跟应用、环境有关，没有放之四海而皆准的法则 –根据实际情况

主要是经验活

1
2
3
4
5
6

/*
查看虚拟机运行参数
"C:\Program Files\Java\jdk1.8.0_91\bin\java" -XX:+PrintFlagsFinal -version | findstr "GC"
 */
public class Demo2_8 {
}

调优领域

• 内存
• 锁竞争
• cpu 占用
• io

调优目标

• 目的是 -> 【低延迟 –互联网项目，追求用户体验】还是【高吞吐量 –科学运算，追求高吞吐量，计算能力】，选择合适的回收器
• CMS，G1，ZGC超低延迟 –响应时间优先
• ParallelGC –高吞吐
• Zing VM –零停顿

最快 GC

最快 GC 是不发生 GC

• 查看 FullGC 前后的内存占用，考虑下面几个问题
  1. 数据是不是太多？
     • resultSet = statement.executeQuery(“select * from 大表 limit n“)
  2. 数据表示是否太臃肿？
     • 对象图，用到什么查什么
     • 对象大小 最小Object 16byte Integer（包装头 16byte） 24byte int 4byte
  3. 是否存在内存泄漏？
     • static Map map = –> 不释放？
     • 软引用
     • 弱引用
     • 第三方缓存实现

新生代调优

新生代优化空间更大

• 新生代的特点
  • 所有的 new 操作的内存分配非常廉价 在 Eden 中
    • TLAB thread-local allocation buffer –new新对象会先判断 TLAB 缓存中是否存在，而 TLAB 的作用除了最为缓存减少new对象开销，还减少了在多线程new对象时的冲突问题（缓存解决冲突原理）
  • 死亡对象的回收代价是零 –被copy的对象，直接覆盖
  • 大部分对象用过即死
  • Minor GC 的时间远远低于 Full GC
• 越大越好吗？
  • 新生代中复制时间 > 标记时间 -> 而新生代通常最终只会有少量的对象存活下来，调大 size 并不会明显减少时间开销，所以并不是越大越好

-Xmn

Sets the initial and maximum size (in bytes) of the heap for the young generation (nursery). GC is performed in this region more often than in other regions. If the size for the young generation is too small, then a lot of minor garbage collections are performed. If the size is too large, then only full garbage collections are performed, which can take a long time to complete. Oracle recommends that you keep the size for the young generation greater than 25% and less than 50% of the overall heap size.

• 新生代能容纳所有【并发量 * (请求-响应的内存)】的数据 –合理值 -> 同一时刻 1000 qps 请求响应占用内存为 512k -> 大约 512m
• 幸存区大到能保留【当前活跃对象+需要晋升对象】
• 晋升阈值配置得当，让存活时间短的对象保存在幸存区，让长时间存活对象尽快晋升

-XX:MaxTenuringThreshold=threshold

-XX:+PrintTenuringDistribution –显示详细信息

1
2
3
4
5

Desired survivor size 48286924 bytes, new threshold 10 (max 10)
- age 1: 28992024 bytes, 28992024 total
- age 2: 1366864 bytes, 30358888 total
- age 3: 1425912 bytes, 31784800 total
...

新生代Size与吞吐量关系

老年代调优

以 CMS 为例

• CMS 的老年代内存越大越好 –CMS并发GC，浮动垃圾，并发失败，SerialOld
• 先尝试不做调优，如果没有 Full GC 那么已经不是 Old 性能卡点…，否则 先尝试调优新生代
• 观察发生 Full GC 时，性能卡点在老年代内存占用，将原有老年代内存预设调大 1/4 ~ 1/3，从而减少 FullGC 次数来降低老年代的 GC 开销
  • -XX:CMSInitiatingOccupancyFraction=percent

较为极端值 -> 将 CMSInitiatingOccupancyFraction 设为 0，只要 Old 产生垃圾就进行回收，这样就不会导致浮动垃圾过多，引发并发失败。缺点是对于 CPU 要求较高，必须控制一定存在一个 CPU 线程，一直处理 OdlGC

常规控制在 70% - 80% -> 提供浮动垃圾的内存

案例

1. 案例1 Full GC 和 Minor GC频繁

   • 新生代 -> 增大内存减少 minor gc
   • 增加晋升阈值 -> 使生命周期较短的对象尽量留在 survive -> 从而减少 Full GC

2. 案例2 请求高峰期发生 Full GC，单次暂停时间特别长 （CMS）

   • 业务需求 -> 低延迟
   • 分析 CMS 哪个阶段耗时较长 -> CMS通常 重新标记阶段开销较大 -> 通过在重新标记之前，进行一次 minor gc 来减少重新标记的开销 -> -XX:+CMSScavengeBeforeRemark -> 减少单次 Full GC开销

3. 案例3 老年代充裕情况下，发生 Full GC （CMS jdk1.7）

   • 永久带原因？ -> jdk1.8之前，永久带的空间不足，同样会触发 Full GC -> 增加元空间的初始值与最大值，来解决永久带空间不足问题

4. 字节码

Java源代码，编译成 Java Class字节码类文件（学习class字节码类文件结构 -> 包含字节码指令，与Java source编译成 class 文件过程中的优化处理）。编译完成后，Java Class字节码类文件需要经过类加载器（ClassLoader，类加载的各个阶段，有哪些类加载器）进行类加载。类加载器将字节码加载到 VM 中，由 VM 执行其中的字节码指令，需要由执行引擎中的 Interpreter（解释器）来进行解释执行，在解释过程中，会对热点代码进行运行期的编译处理（JavaVM 是通过解释和编译来运行的 -> 需要了解运行期间的优化有一定理解）

Java Source -> javac -> 0x字节码与字节码指令 -> 解释（-> Interpreter解释器，部分查表，部分解释成机器码指令） -> 运行时进行部分及时编译（JIT）

类文件结构

分析类文件结构

HelloWorld.java

1
2
3
4
5
6

// HelloWorld 示例
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

执行 javac -parameters -d . HellowWorld.java

-parameters -d 编译后保留方法中参数的名称信息

编译为 HelloWorld.class 后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

[root@localhost ~]# od -t xC HelloWorld.class
0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09
0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07
0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29
0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e
0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63
0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01
0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63
0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f
0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16
0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72
0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13
0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69
0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61
0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46
0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64
0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e
0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64
0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74
0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c
0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61
0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61
0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f
0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72
0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76
0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d
0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a
0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b
0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01
0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01
0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00
0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00
0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00
0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00
0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a
0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b
0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00
0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00
0001120 00 00 02 00 14

根据 JVM 规范，类文件结构如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ClassFile {
    u4              magic;	// 前4字节
    u2              minor_version;	// 接下来2字节
    u2              major_version;
    u2              constant_pool_count;
    cp_info         constant_pool[constant_pool_count-1];
    u2              access_flags;	// 访问修饰
    u2              this_class;	//类名 包名
    u2              super_class;	// 父类
    u2              interfaces_count;	// 接口信息
    u2              interfaces[interfaces_count];
    u2              fields_count;
    field_info      fields[fields_count];
    u2              methods_count;
    method_info     methods[methods_count];
    u2              attributes_count;	// 类附加的属性信息
    attribute_info  attributes[attributes_count];
}

魔数

Magic Number -> A constant numerical or text value used to identify a file format。

魔数 -> 标识文件的格式使用魔数，而不是扩展名。主要是基于安全方面的考虑，因为文件的扩展名是可以随意修改的，例如 PDF文件魔数使用的文本值”%PDF”（ASCII字符），底层编码十六进制形式（25 50 44 46）；GIF文件的魔数使用的文本值”GIF89a”（ASCII字符），底层编码十六进制形式 (47 49 46 38 39 61) 。Java的Class文件魔数使用数值“CAFEBABE”（十六进制），底层编码就是该数值，.java文件魔数使用数值”CAFEDEAD”
参考文档

参考文档

0~3 字节，表示它是否是【class】类型的文件

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

版本

4~7 字节，表示类的版本 00 34（52） 表示是 Java 8 –指体现了 jdk8 大版本，没有体现小版本

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

51 jdk7

52 jdk8

53 jdk9

常量池

常量池占用整个 class 文件中较大的比重

• ==89 字节，表示常量池长度（整个常量池中有多少项），00 23 （35） 表示常量池有 #1#34项，注意 #0 项不计入，也没有值==

  0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

1. 第#1项 0a 表示一个 Method（查常量池表 -> 表示一个方法引用信息） 信息（常量的类型信息），00 06 和 00 15（21） 表示它引用了常量池中 #6 和 #21 项来获得这个方法的【所属类】和【方法名】

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

2. 第#2项 09 表示一个 Field 信息，00 16（22）和 00 17（23） 表示它引用了常量池中 #22 和 # 23 项来获得这个成员变量的【所属类】和【成员变量名】

0000000 ca fe ba be 00 00 00 34 00 23 0a 00 06 00 15 09

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

3. 第#3项 08 表示一个字符串常量名称，00 18（24）表示它引用了常量池中 #24 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

4. 第#4项 0a 表示一个 Method 信息，00 19（25） 和 00 1a（26） 表示它引用了常量池中 #25 和 #26 项来获得这个方法的【所属类】和【方法名】

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

5. 第#5项 07 表示一个 Class 信息，00 1b（27） 表示它引用了常量池中 #27 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

6. 第#6项 07 表示一个 Class 信息，00 1c（28） 表示它引用了常量池中 #28 项

0000020 00 16 00 17 08 00 18 0a 00 19 00 1a 07 00 1b 07

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

7. 第#7项 01 表示一个 utf8 串，00 06 表示长度，3c 69 6e 69 74 3e 是【 <init> -> 表示类的构造方法】

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

8. 第#8项 01 表示一个 utf8 串，00 03 表示长度，28 29 56 是【()V】其实就是表示无参、无返回值

0000040 00 1c 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

9. 第#9项 01 表示一个 utf8 串，00 04 表示长度，43 6f 64 65 是【Code】

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

10. 第#10项 01 表示一个 utf8 串，00 0f（15） 表示长度，4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c 65 是【LineNumberTable】

0000060 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e

0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63

11. 第#11项 01 表示一个 utf8 串，00 12（18） 表示长度，4c 6f 63 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65是【LocalVariableTable】

0000100 75 6d 62 65 72 54 61 62 6c 65 01 00 12 4c 6f 63

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01

12. 第#12项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【this】

0000120 61 6c 56 61 72 69 61 62 6c 65 54 61 62 6c 65 01

0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63

13. 第#13项 01 表示一个 utf8 串，00 1d（29） 表示长度，是【Lcn/itcast/jvm/t5/HelloWorld;】-> 引用类型

0000140 00 04 74 68 69 73 01 00 1d 4c 63 6e 2f 69 74 63

0000160 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c 6f

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

14. 第#14项 01 表示一个 utf8 串，00 04 表示长度，74 68 69 73 是【main】

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

15. 第#15项 01 表示一个 utf8 串，00 16（22） 表示长度，是【([Ljava/lang/String;)V】-> 参数类型和返回类型，其实就是参数为字符串数组，无返回值

0000200 57 6f 72 6c 64 3b 01 00 04 6d 61 69 6e 01 00 16

0000220 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

16. 第#16项 01 表示一个 utf8 串，00 04 表示长度，是【args】-> 参数名称

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

17. 第#17项 01 表示一个 utf8 串，00 13（19） 表示长度，是【[Ljava/lang/String;】-> 参数类型

0000240 69 6e 67 3b 29 56 01 00 04 61 72 67 73 01 00 13

0000260 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

18. 第#18项 01 表示一个 utf8 串，00 10（16） 表示长度，是【MethodParameters】-> 方法参数信息

0000300 6e 67 3b 01 00 10 4d 65 74 68 6f 64 50 61 72 61

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

19. 第#19项 01 表示一个 utf8 串，00 0a（10） 表示长度，是【SourceFile】-> 类属性信息，源文件

0000320 6d 65 74 65 72 73 01 00 0a 53 6f 75 72 63 65 46

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

20. 第#20项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【HelloWorld.java】

0000340 69 6c 65 01 00 0f 48 65 6c 6c 6f 57 6f 72 6c 64

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

21. 第#21项 0c 表示一个 【名+类型】，00 07 00 08 引用了常量池中 #7 #8 两项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

22. 第#22项 07 表示一个 Class 信息，00 1d（29） 引用了常量池中 #29 项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

23. 第#23项 0c 表示一个 【名+类型】，00 1e（30） 00 1f （31）引用了常量池中 #30 #31 两项

0000360 2e 6a 61 76 61 0c 00 07 00 08 07 00 1d 0c 00 1e

0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64

24. 第#24项 01 表示一个 utf8 串，00 0f（15） 表示长度，是【hello world】

0000400 00 1f 01 00 0b 68 65 6c 6c 6f 20 77 6f 72 6c 64

25. 第#25项 07 表示一个 Class 信息，00 20（32） 引用了常量池中 #32 项

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

26. 第#26项 0c 表示一个 【名+类型】，00 21（33） 00 22（34）引用了常量池中 #33 #34 两项

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

27. 第#27项 01 表示一个 utf8 串，00 1b（27） 表示长度，是【cn/itcast/jvm/t5/HelloWorld】

0000420 07 00 20 0c 00 21 00 22 01 00 1b 63 6e 2f 69 74

0000440 63 61 73 74 2f 6a 76 6d 2f 74 35 2f 48 65 6c 6c

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61

28. 第#28项 01 表示一个 utf8 串，00 10（16） 表示长度，是【java/lang/Object】

0000460 6f 57 6f 72 6c 64 01 00 10 6a 61 76 61 2f 6c 61

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61

29. 第#29项 01 表示一个 utf8 串，00 10（16） 表示长度，是【java/lang/System】

0000500 6e 67 2f 4f 62 6a 65 63 74 01 00 10 6a 61 76 61

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f

30. 第#30项 01 表示一个 utf8 串，00 03 表示长度，是【out】

0000520 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 01 00 03 6f

0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72

31. 第#31项 01 表示一个 utf8 串，00 15（21） 表示长度，是【Ljava/io/PrintStream;】

0000540 75 74 01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72

0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76

32. 第#32项 01 表示一个 utf8 串，00 13（19） 表示长度，是【java/io/PrintStream】

0000560 69 6e 74 53 74 72 65 61 6d 3b 01 00 13 6a 61 76

0000600 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d

33. 第#33项 01 表示一个 utf8 串，00 07 表示长度，是【println】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

34. 第#34项 01 表示一个 utf8 串，00 15（21） 表示长度，是【(Ljava/lang/String;)V】

0000620 01 00 07 70 72 69 6e 74 6c 6e 01 00 15 28 4c 6a

0000640 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

访问标识与继承信息

21 表示该 class 是一个类，公共的 20 + 1 -> 公共类

• 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

05 表示根据常量池中 #5 找到本类全限定名

• 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

06 表示根据常量池中 #6 找到父类全限定名

• 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

表示接口的数量，本类为 0

• 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

Field 信息

表示成员变量数量，本类为 0

• 0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

Method 信息

表示方法数量，本类为 2

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

一个方法由 访问修饰符，名称，参数描述，方法属性数量，方法属性组成

• 红色代表访问修饰符（本类中是 public）
• 蓝色代表引用了常量池 #07 项作为方法名称
• 绿色代表引用了常量池 #08 项作为方法参数描述
• 黄色代表方法属性数量，本方法是 1
• 红色代表方法属性
  • 00 09 表示引用了常量池 #09 项，发现是【Code】属性
  • 00 00 00 2f 表示此属性的长度是 47
  • 00 01 表示【操作数栈】最大深度
  • 00 01 表示【局部变量表】最大槽（slot）数
  • 00 00 00 05 表示字节码长度，本例是 5
  • 2a b7 00 01 b1 是字节码指令
  • 00 00 00 02 表示方法细节属性数量，本例是 2
  • 00 0a 表示引用了常量池 #10 项，发现是【LineNumberTable】属性
    • 00 00 00 06 表示此属性的总长度，本例是 6
    • 00 01 表示【LineNumberTable】长度
    • 00 00 表示【字节码】行号 00 04 表示【java 源码】行号
  • 00 0b 表示引用了常量池 #11 项，发现是【LocalVariableTable】属性
    • 00 00 00 0c 表示此属性的总长度，本例是 12
    • 00 01 表示【LocalVariableTable】长度
    • 00 00 表示局部变量生命周期开始，相对于字节码的偏移量
    • 00 05 表示局部变量覆盖的范围长度
    • 00 0c 表示局部变量名称，本例引用了常量池 #12 项，是【this】
    • 00 0d 表示局部变量的类型，本例引用了常量池 #13 项，是 【Lcn/itcast/jvm/t5/HelloWorld;】
    • 00 00 表示局部变量占有的槽位（slot）编号，本例是 0

0000660 29 56 00 21 00 05 00 06 00 00 00 00 00 02 00 01

0000700 00 07 00 08 00 01 00 09 00 00 00 2f 00 01 00 01

0000720 00 00 00 05 2a b7 00 01 b1 00 00 00 02 00 0a 00

0000740 00 00 06 00 01 00 00 00 04 00 0b 00 00 00 0c 00

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00

• 红色代表访问修饰符（本类中是 public 01 static 08）
• 蓝色代表引用了常量池 #14 项作为方法名称
• 绿色代表引用了常量池 #15 项作为方法参数描述
• 黄色代表方法属性数量，本方法是 2
• 红色代表方法属性（属性1）
  • 00 09 表示引用了常量池 #09 项，发现是【Code】属性
  • 00 00 00 37 表示此属性的长度是 55
  • 00 02 表示【操作数栈】最大深度
  • 00 01 表示【局部变量表】最大槽（slot）数
  • 00 00 00 05 表示字节码长度，本例是 9
  • b2 00 02 12 03 b6 00 04 b1 是字节码指令
  • 00 00 00 02 表示方法细节属性数量，本例是 2
  • 00 0a 表示引用了常量池 #10 项，发现是【LineNumberTable】属性
    • 00 00 00 0a 表示此属性的总长度，本例是 10
    • 00 02 表示【LineNumberTable】长度
    • 00 00 表示【字节码】行号 00 06 表示【java 源码】行号
    • 00 08 表示【字节码】行号 00 07 表示【java 源码】行号
  • 00 0b 表示引用了常量池 #11 项，发现是【LocalVariableTable】属性
    • 00 00 00 0c 表示此属性的总长度，本例是 12
    • 00 01 表示【LocalVariableTable】长度
    • 00 00 表示局部变量生命周期开始，相对于字节码的偏移量
    • 00 09 表示局部变量覆盖的范围长度
    • 00 10 表示局部变量名称，本例引用了常量池 #16 项，是【args】
    • 00 11 表示局部变量的类型，本例引用了常量池 #17 项，是【[Ljava/lang/String;】
    • 00 00 表示局部变量占有的槽位（slot）编号，本例是 0

0000760 01 00 00 00 05 00 0c 00 0d 00 00 00 09 00 0e 00

0001000 0f 00 02 00 09 00 00 00 37 00 02 00 01 00 00 00

0001020 09 b2 00 02 12 03 b6 00 04 b1 00 00 00 02 00 0a

0001040 00 00 00 0a 00 02 00 00 00 06 00 08 00 07 00 0b

0001060 00 00 00 0c 00 01 00 00 00 09 00 10 00 11 00 00

红色代表方法属性（属性2）

• 00 12 表示引用了常量池 #18 项，发现是【MethodParameters】属性
  • 00 00 00 05 表示此属性的总长度，本例是 5
  • 01 参数数量
  • 00 10 表示引用了常量池 #16 项，是【args】
  • 00 00 访问修饰符

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00

0001120 00 00 02 00 14

附加属性

• 00 01 表示附加属性数量
• 00 13 表示引用了常量池 #19 项，即【SourceFile】
• 00 00 00 02 表示此属性的长度
• 00 14 表示引用了常量池 #20 项，即【HelloWorld.java】

0001100 00 12 00 00 00 05 01 00 10 00 00 00 01 00 13 00

0001120 00 00 02 00 14

参考文献 -Java虚拟机规范

字节码指令

字节码指令理论

接着上一节，研究一下两组字节码指令，一个是

public cn.itcast.jvm.t5.HelloWorld(); 构造方法的字节码指令

1

2a b7 00 01 b1

==jvm通过 解释器（Interpreter）来识别以上VM平台无关的字节码指令，将其解释成机器码，然后直接执行机器码== -> ==字节码指令可以通过查看官方文档，解释成 **操作码(助记符)**，使其便于阅读==

1. 2a => aload_0（注记符->便于我们查看） 加载 slot 0 的局部变量（**-> 到操作数栈上，JVM解释器执行时需要到操作数栈上读取数据**），即 this，做为下面的 invokespecial 构造方法调用的参数
2. b7 => invokespecial 预备调用构造方法，哪个方法呢？
3. 00 01 引用常量池中 #1 项，即【 Method java/lang/Object."":()V 】
4. b1 表示返回 return

另一个是 public static void main(java.lang.String[]); 主方法的字节码指令

1

b2 00 02 12 03 b6 00 04 b1

1. b2 => getstatic 用来加载静态变量（加载到操作数栈上），哪个静态变量呢？
2. 00 02 引用常量池中 #2 项，即【Field java/lang/System.out:Ljava/io/PrintStream;】
3. 12 => ldc 加载参数，哪个参数呢？
4. 03 引用常量池中 #3 项，即 【String hello world】
5. b6 => invokevirtual 预备调用成员方法，哪个方法呢？
6. 00 04 引用常量池中 #4 项，即【Method java/io/PrintStream.println:(Ljava/lang/String;)V】
7. b1 表示返回 return

参考文档

javap 工具

由于分析类文件结构过于麻烦，Oracle 提供了 javap 工具来反编译 class 文件

javap -v HelloWorld.class -> -v 表示输出详细信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

[root@localhost ~]# javap -v HelloWorld.class
Classfile /root/HelloWorld.class
    Last modified Jul 7, 2019; size 597 bytes
    MD5 checksum 361dca1c3f4ae38644a9cd5060ac6dbc
    Compiled from "HelloWorld.java"
public class cn.itcast.jvm.t5.HelloWorld
    minor version: 0
    major version: 52
    flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
    #1 = Methodref      #6.#21 // java/lang/Object."<init>":()V
    #2 = Fieldref       #22.#23 //
    java/lang/System.out:Ljava/io/PrintStream;
    #3 = String         #24 // hello world
    #4 = Methodref      #25.#26 // java/io/PrintStream.println:
    (Ljava/lang/String;)V
    #5 = Class          #27 // cn/itcast/jvm/t5/HelloWorld
    #6 = Class          #28 // java/lang/Object
    #7 = Utf8           <init>
    #8 = Utf8           ()V
    #9 = Utf8           Code
    #10 = Utf8          LineNumberTable
    #11 = Utf8          LocalVariableTable
    #12 = Utf8          this
    #13 = Utf8          Lcn/itcast/jvm/t5/HelloWorld;
    #14 = Utf8          main
    #15 = Utf8          ([Ljava/lang/String;)V
    #16 = Utf8          args
    #17 = Utf8          [Ljava/lang/String;
    #18 = Utf8          MethodParameters
    #19 = Utf8          SourceFile
    #20 = Utf8          HelloWorld.java
    #21 = NameAndType   #7:#8 // "<init>":()V
    #22 = Class         #29 // java/lang/System
    #23 = NameAndType   #30:#31 // out:Ljava/io/PrintStream;
    #24 = Utf8          hello world
    #25 = Class         #32 // java/io/PrintStream
    #26 = NameAndType   #33:#34 // println:(Ljava/lang/String;)V
    #27 = Utf8          cn/itcast/jvm/t5/HelloWorld
    #28 = Utf8          java/lang/Object
    #29 = Utf8          java/lang/System
    #30 = Utf8          out
    #31 = Utf8          Ljava/io/PrintStream;
    #32 = Utf8          java/io/PrintStream
    #33 = Utf8          println
    #34 = Utf8          (Ljava/lang/String;)V

{
    public cn.itcast.jvm.t5.HelloWorld();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
            stack=1, locals=1, args_size=1
                0: aload_0
                1: invokespecial #1 // Method java/lang/Object." <init>":()V
                4: return
            LineNumberTable:
                line 4: 0
            LocalVariableTable:
                Start Length Slot Name Signature
                    0      5    0 this Lcn/itcast/jvm/t5/HelloWorld;
    public static void main(java.lang.String[]);
        descriptor: ([Ljava/lang/String;)V
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
            stack=2, locals=1, args_size=1
            0: getstatic #2 // Field
    java/lang/System.out:Ljava/io/PrintStream;
            3: ldc #3 // String hello world
            5: invokevirtual #4 // Method
    java/io/PrintStream.println:(Ljava/lang/String;)V
            8: return
        LineNumberTable:
            line 6: 0
            line 7: 8
        LocalVariableTable:
            Start Length Slot Name Signature
                0      9    0 args [Ljava/lang/String;
        MethodParameters:
            Name    Flags
            args
}

javap 反编译工具来帮助我们简化阅读 class 字节码文件 -> 更清晰阅读字节码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

E:\Todo\note\Software\Java_Note\JVM_Note>javap -v HelloWorld.class
Classfile /E:/Todo/note/Software/Java_Note/JVM_Note/HelloWorld.class
  Last modified 2023-1-30; size 432 bytes
  MD5 checksum d3dace27df9ccf67c8b58b911541fa63
  Compiled from "HelloWorld.java"
public class Test02.HelloWorld
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // hello world
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // Test02/HelloWorld
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               HelloWorld.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               hello world
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               Test02/HelloWorld
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public Test02.HelloWorld();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8
}
SourceFile: "HelloWorld.java"

图解方法执行流程

java 代码

1
2
3
4
5
6
7
8
9
10
11

/**
* 演示 字节码指令 和 操作数栈、常量池的关系
*/
public class Demo3_1 {
    public static void main(String[] args) {
        int a = 10;
        int b = Short.MAX_VALUE + 1;
        int c = a + b;
        System.out.println(c);
    }
}

编译后字节码文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100